var express = require('express');
var router = express.Router();
const { userSchemaModel,chuangZuoSchemaModel,zhangJieModel } = require('../model/model');

/* GET home page. */
router.get('/123', function(req, res, next) {
  res.render('index', { title: '成功' });
});
//添加用户，单纯的添加
router.post('/addUser', async (req, res) => {
  console.log('触发添加userSchemaModel');
  try {
      // 从请求体中获取用户信息
      const { username, avatar, dengj } = req.body;

      // 创建用户实例
      const newUser = new userSchemaModel({
          username,
          avatar,
          dengj,
      });

      // 保存用户到数据库
      const savedUser = await newUser.save();

      res.status(201).json(savedUser);  // 返回保存后的用户数据
  } catch (error) {
      console.error(error);
      res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 添加创作，这里的创作weiid不能是空的要和用户对应
router.post('/addChuangZuo', async (req, res) => {
  console.log('触发添加chuangZuoSchemaModel');
  try {
    // 从请求体中获取创作所需字段
    const { title, content, tuavatar, fabu, weiid } = req.body;

    // 检查关联的用户是否存在
    const existingUser = await userSchemaModel.findById(weiid);
    if (!existingUser) {
      return res.status(400).json({ error: '关联的用户不存在' });
    }

    // 创建新创作实例
    const newChuangZuo = new chuangZuoSchemaModel({
      title,
      content,
      tuavatar,
      fabu,
      weiid,
    });

    // 尝试将新创作保存到数据库
    const savedChuangZuo = await newChuangZuo.save();

    // 返回成功的响应，包含新创作的信息
    res.status(201).json(savedChuangZuo);
  } catch (error) {
    // 捕捉任何错误并返回500内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 添加章节，weiid也是不能为空要和小说id对应，这是能重复的
router.post('/addZhangJie', async (req, res) => {
  console.log('触发添加 zhangJieModel');
  try {
    // 从请求体中获取章节所需字段
    const { zhangtitle, zhengwen, weiid } = req.body;

    // 检查关联的创作是否存在
    const existingChuangZuo = await chuangZuoSchemaModel.findById(weiid);
    if (!existingChuangZuo) {
      return res.status(400).json({ error: '关联的创作不存在' });
    }

    // 创建新章节实例
    const newZhangJie = new zhangJieModel({
      zhangtitle,
      zhengwen,
      weiid,
    });

    // 尝试将新章节保存到数据库
    const savedZhangJie = await newZhangJie.save();

    // 返回成功的响应，包含新章节的信息
    res.status(201).json(savedZhangJie);
  } catch (error) {
    // 捕捉任何错误并返回500内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询所有章节，这是直接获取所有章节没有过滤没有对应的小说，就是单纯的返回所有(一般没什么用)
router.get('/getAllZhangJie', async (req, res) => {
  try {
    const allZhangJie = await zhangJieModel.find();
    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 小说对应查询所有章节，这里查询到的是所有章节，但他包含每个章节对应的小说
router.get('/getZhangJie', async (req, res) => {
  try {
    const allZhangJie = await zhangJieModel.find().populate('weiid');
    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询创作这就是所有小说，单纯查所有小说，一般写首页的用到
router.get('/getChuangZuo', async (req, res) => {
  console.log('触发查询创作接口');
  try {
    // 查询数据库中所有创作
    const allChuangZuo = await chuangZuoSchemaModel.find();

    // 返回所有创作的信息
    res.status(200).json(allChuangZuo);
  } catch (error) {
    // 捕捉任何错误并返回500内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询所有创作,这里包含用户信息和对应用户的小说，
router.get('/getAllChuangZuo', async (req, res) => {
  console.log('触发查询所有创作接口');
  try {
    // 查询数据库中所有创作，并将关联的用户信息填充到结果中
    const allChuangZuo = await chuangZuoSchemaModel.find().populate('weiid', 'username avatar');

    // 返回所有创作的信息
    res.status(200).json(allChuangZuo);
  } catch (error) {
    // 捕捉任何错误并返回500内部服务器错误
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询所有用户，单纯的查询所有用户
router.get('/getUsers', async (req, res) => {
  try {
    const allUsers = await userSchemaModel.find();
    res.status(200).json(allUsers);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询某个创作下的所有章节，返回的信息也有对应weiid的内容
router.get('/getZhangJieByChuangZuoId/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;

    const allZhangJie = await zhangJieModel
      .find({ weiid: chuangZuoId })
      .populate('weiid');

    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询某个小说下的所有章节，只会返回章节，和内容
router.get('/getZhangJiexiao/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;
    const allZhangJie = await zhangJieModel
      .find({ weiid: chuangZuoId });

    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 获取章节内容                     
// 演示http://localhost:3000/sen/getZhangJieneirong/659e0f41bee25d7d88bda176?zhangtitle=第二章-开学
// 这要是?zhangtitle=第二章-开学没有，他默认返回所有对应小说的章节
router.get('/getZhangJieneirong/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;
    const { zhangtitle } = req.query; // 从查询参数获取 zhangtitle

    // 构建查询条件
    const query = { weiid: chuangZuoId };
    if (zhangtitle) {
      // 如果提供了 zhangtitle 查询参数，添加到查询条件中
      query.zhangtitle = zhangtitle;
    }

    // 执行查询
    const allZhangJie = await zhangJieModel.find(query);

    res.status(200).json(allZhangJie);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});

// 搜索接口，用于首页的模糊搜索，搜的是小说名字
router.get('/search/:keyword', async (req, res) => {
  try {
    const keyword = req.params.keyword;
    
    // 使用正则表达式进行模糊搜索
    const searchResults = await chuangZuoSchemaModel.find({ title: { $regex: keyword, $options: 'i' } });

    res.status(200).json(searchResults);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 修改小说介绍标题等信息接口
router.put('/updateChuangZuo/:chuangZuoId', async (req, res) => {
  try {
    const { chuangZuoId } = req.params;
    const updateFields = req.body; // 从请求体获取要更新的字段

    // 尝试更新小说信息
    const updatedChuangZuo = await chuangZuoSchemaModel.findByIdAndUpdate(
      chuangZuoId,
      { $set: updateFields },
      { new: true }
    );

    // 检查小说是否存在
    if (!updatedChuangZuo) {
      return res.status(404).json({ error: '小说不存在' });
    }

    res.status(200).json(updatedChuangZuo);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});


// 书架，要求传用户id和书架的id
router.post('/collectBook/:userId/:chuangZuoId', async (req, res) => {
  try {
      const { userId, chuangZuoId } = req.params;

      // 检查用户和图书是否存在
      const user = await userSchemaModel.findById(userId);
      const chuangZuo = await chuangZuoSchemaModel.findById(chuangZuoId);

      if (!user || !chuangZuo) {
          return res.status(404).json({ error: '用户或图书不存在' });
      }

      // 更新用户的 collections 数组，添加收藏的图书
      user.collections.push(chuangZuoId);
      await user.save();

      res.status(200).json({ success: true });
  } catch (error) {
      console.error(error);
      res.status(500).json({ error: 'Internal Server Error' });
  }
});



// 查询用户收藏的图书
router.get('/getUserShoucangs/:userId', async (req, res) => {
  try {
    const { userId } = req.params;

    // 查询用户信息，包括收藏的图书ID数组
    const user = await userSchemaModel.findById(userId).select('collections');

    if (!user) {
      return res.status(404).json({ error: '用户不存在' });
    }

    // 获取用户收藏的图书ID数组
    const collections = user.collections || [];

    // 查询收藏的图书信息
    const shoucangBooks = await chuangZuoSchemaModel.find({ _id: { $in: collections } });

    res.status(200).json(shoucangBooks);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});

module.exports = router;